package com.jt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.ItemCatMapper;
import com.jt.pojo.ItemCat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author tang
 * @data 2021/9/3
 * @apiNode
 */
@Service
public class ItemCatServiceImpl implements ItemCatService{
    @Autowired
    private ItemCatMapper itemCatMapper;

    /**
     * 业务说明:实现商品分类查询
     * url:"itemCat/findItemCatList/{level}"
     * 参数:level  查询的层数
     * 返回值:SysResult(List)
     * @param level
     * @return
     */
    //@Override
    //public List<ItemCat> findItemCatList(Integer level) {
    //    QueryWrapper<ItemCat> itemCatQueryWrapper = new QueryWrapper<>();
    //    itemCatQueryWrapper.eq("level", 1);
    //    List<ItemCat> itemCatList1 = itemCatMapper.selectList(itemCatQueryWrapper);  //查询一级
    //
    //    for (ItemCat itemCat : itemCatList1) {  //遍历一级
    //        itemCatQueryWrapper.clear();  //清空条件构造器
    //        itemCatQueryWrapper.eq("parent_id", itemCat.getId());
    //        List<ItemCat> itemCatList2 = itemCatMapper.selectList(itemCatQueryWrapper);  //查询二级
    //
    //        for (ItemCat cat : itemCatList2) {  //遍历二级
    //            itemCatQueryWrapper.clear();  //清空条件构造器
    //            itemCatQueryWrapper.eq("parent_id", cat.getId());
    //            List<ItemCat> itemCatList3 = itemCatMapper.selectList(itemCatQueryWrapper);  //查询三级
    //            cat.setChildren(itemCatList3);  //三级封装到二级的children
    //        }
    //        itemCat.setChildren(itemCatList2);  //二级封装到一级的children
    //    }
    //    return itemCatList1;
    //}

    /**
     * 1.数据结构:  map<K,V>   key=parentId  value="List<ItemCat>"
     * 2.封装Map的数据结构
     * 3.如果level=1,只获取一级
     * 4.如果level=2,只获取一级,封装二级
     * 5.如果level=3,只获取一级,封装二级，封装三级
     * @param level
     * @return
     */
    @Override
    public List<ItemCat> findItemCatList(Integer level){
        Map<Integer,List<ItemCat>> map = getMap();   //map<K,V>   key=parentId  value="List<ItemCat>"
        if(level == 1){
            return map.get(0);   //父级id为0  即第一级
        }else if(level == 2){
            return getTwoList(map);
        }else{
            return getThreeList(map);
        }
    }

    @Override
    @Transactional
    public void updateItemCatStatus(ItemCat itemCat) {
        itemCatMapper.updateById(itemCat);
    }

    @Override
    @Transactional
    public void saveItemCat(ItemCat itemCat) {
        itemCat.setStatus(true);
        itemCatMapper.insert(itemCat);
    }

    @Override
    @Transactional
    public void updateItemCat(ItemCat itemCat) {
        itemCatMapper.updateById(itemCat);
    }

    /**
     * 需求:删除商品分类信息
     * 条件:如果有子集,先删除子集
     * @param itemCat
     */
    @Override
    @Transactional
    public void deleteItemCat(ItemCat itemCat) {
        int Level = itemCat.getLevel();
        if(Level == 3){
            itemCatMapper.deleteById(itemCat.getId());
        }

        if (Level == 2){
            itemCatMapper.delete(new QueryWrapper<ItemCat>()
                    .eq("parent_id", itemCat.getId())
                    .or()
                    .eq("id",itemCat.getId()));
        }

        if(Level == 1){
            List twoIdsList = itemCatMapper.selectObjs(new QueryWrapper<ItemCat>().eq("parent_id", itemCat.getId()));  //二级标题的id
            itemCatMapper.delete(new QueryWrapper<ItemCat>()
                    .in(twoIdsList.size()>0,"parent_id",twoIdsList)  //删parent_id为二级id的数据  即三级数据
                    .or()
                    .eq("parent_id", itemCat.getId())  //删除parent_id为一级id的数据   即二级数据
                    .or()
                    .eq("id", itemCat.getId()));  //删除一级
        }
    }

    private List<ItemCat> getThreeList(Map<Integer, List<ItemCat>> map) {  //三级封装到二级,二级封装到一级
        List<ItemCat> oneList = getTwoList(map);
        for (ItemCat itemCat : oneList) {
            List<ItemCat> twolist = itemCat.getChildren();
            if (twolist == null || twolist.size() == 0){
                continue;
            }
            for (ItemCat twoItemCat : twolist) {
                int parentId = twoItemCat.getId();
                List<ItemCat> threeList = map.get(parentId);
                twoItemCat.setChildren(threeList);
            }
        }
        return oneList;
    }

    private List<ItemCat> getTwoList(Map<Integer, List<ItemCat>> map) {//二级封装到一级
        List<ItemCat> itemCatList = map.get(0);  //获取一级分类
        for (ItemCat itemCat : itemCatList) {  //循环遍历一级
            int parentId = itemCat.getId();  //二级的父级id为一级id
            List<ItemCat> twoList = map.get(parentId);  //将父级id封装到map中作为key
            itemCat.setChildren(twoList);   //一级列表利用children封装二级列表
        }
        return itemCatList;
    }

    /**
     * 1.查询所有的商品的分类列表,查询一次数据库
     * 2.循环遍历所有的数据,按照parentId,List<ItemCat>方式封装数据
     * @return
     */
    private Map<Integer, List<ItemCat>> getMap() {
        Map<Integer,List<ItemCat>> map = new HashMap<>();   //创建map对象  key=parentId  value="List<ItemCat>"
        List<ItemCat> list = itemCatMapper.selectList(null);  //一次性查询完   查询全部
        for (ItemCat itemCat : list) {  //遍历查询的列表
            int parentId = itemCat.getParentId();   //获取列表中所有数据的父级id
            if(map.containsKey(itemCat.getParentId())){  //判断这个父级id(key)是否在map中
                map.get(parentId).add(itemCat);  //如果在则直接吧数据插入到value中
            }else {
                List<ItemCat> childrenList = new ArrayList<>();  //创建list数组
                childrenList.add(itemCat);  //把循环遍历得到的数据封装进list集合
                map.put(parentId, childrenList);  //封装到map
            }
        }
        return map;

    }
}
